package java_thinking.unit_10._10_6;


/**
 * @Description :
 * @author: cww
 * @DateTime: 2019-03-10 17:27
 */

interface Service{
    void method1();
    void method2();
}
interface ServiceFactory {
    Service getService();
}
class Implementation1 implements Service {
    private static int i = 0;
    private static String s = "2";
    /**
     * 常量类不可被改变
     */
    private final int b = 2;
    /**
     * final对象的引用地址不可变，但是被引用的对象内部的值是可以改变的
     */
    private final String s2 = s;
    /**
     * 这里构造器都可以是private的，如果不是使用匿名内部类方式，这里必须是public类型的外部才能对他进行初始化构造并引用
     */
    private Implementation1(){};
    @Override
    public void method1() {
        i = 2;
        s = "2";

        System.out.println("Implementation1.method1");
    }

    @Override
    public void method2() {
        System.out.println("Implementation1.method2");
    }

    /**
     * 匿名内部类产生接口的实现对象
     * factory指向了ServiceFactory对象的引用地址
     * 这个对象里面有一个getService方法，返回的是Service类型
     * 这样就不需要像java_thinking/unit_9/_9_9/Service.java中一样多一步去new一个Implementation2Factory()对象了
     * 而且，我们经常只需要单一的工厂对象。因此在这里被创建为Service实现中的一个static域，这样的语法更有意义
     */
    public static ServiceFactory factory = new ServiceFactory() {

        @Override
        public Service getService() {
            return new Implementation1();
        }
    };
}

class Factories{
    public static void serviceConsumer(ServiceFactory serviceFactory){
        Service service = serviceFactory.getService();
        service.method1();
    }

    public static void main(String[] args) {
        serviceConsumer(Implementation1.factory);
    }
}
